// 使用sequelize，每一个表只需要执行一次，否则设置有索引的表会重复创建，次数多了会超出限制，项目运行会报错
// sync参数为空：如果表不存在，则创建表 alter:true 会自动创建表并更新 force: true强制删除并重新创建
/**
 * @description 同步数据库，需要手动调整需要同步的内容
 * @description syncModels - 创建了数据库之后啥都没有才执行
 * @description 单独的表 - 首次创建表或者表结构发生改变时执行
 * @description 结构发生改变 - 如果是单个表发生改变并且没有设置索引，xxx.sync({alter:true})
 * @description 结构发生改变 - 如果是有索引，则保存好数据后，使用xxx.sync({force:true})，再恢复数据
 * @description 结构发生改变 - 如果是有和其他的表有关联则需要导出数据，然后删除表，再重新创建，最后恢复数据
 * @description 结构发生改变 - 如果都不行就得手动的修改
 */

// 引入数据库同步函数
const sequelize = require('@/config/db');
const syncModels = require('@/models/index')
const User = require("@/models/user.models")
const Role = require("@/models/role.models")
const UserRole = require("@/models/userRole.models")
const Route = require("@/models/route.models")
const RoleRoute = require("@/models/roleRoute.models");
const { error } = require('winston');

async function syncDB() {
  try {
    // 同步整个数据库以及表结构{ force: true }
    await syncModels();
    // 同步用户表
    // await User.sync({ force: true });
    // 同步角色表
    // await Role.sync({ force: true });
    // 同步用户角色关联表
    // await UserRole.sync({ force: true });
    // 同步路由表
    // await Route.sync({ force: true });
    // 同步角色路由关联表
    // await RoleRoute.sync({ force: true });
    console.log('数据库同步成功');
  } catch (error) {
    console.error('数据库同步失败:', error);
  }
}

async function defaultData() {
  try {
    await initRoleData()
    await initUserData()
    await initUserRoleData()
    await initRouteData()
    await initRoleRouteData()
    console.log('默认数据初始化成功');
  } catch (error) {
    console.error('默认数据初始化失败:', error);
  }
}

/**
 * 默认角色数据
 */
async function initRoleData() {
  try {
    // 验证数据库连接
    await sequelize.authenticate();
    await Role.sync().then(async () => {
      const existingRole1 = await Role.findByPk(1);
      const existingRole2 = await Role.findByPk(2);
      const existingRole3 = await Role.findByPk(3);

      if (!existingRole1 && !existingRole2 && !existingRole3) {
        console.log('默认角色数据不存在');
        await Role.bulkCreate([
          { name: 'admin', description: '管理员' },
          { name: 'user', description: '普通用户' },
          { name: 'test', description: '测试用户' }
        ], { ignoreDuplicates: true });
      }
    });
  } catch (error) {
    console.error('设置默认角色数据出错：', error);
  }

}

/**
 * 默认用户数据
 */
async function initUserData() {
  try {
    // 验证数据库连接
    await sequelize.authenticate();
    await User.sync().then(async () => {
      const existingUser = await User.findByPk(1);

      if (!existingUser) {
        await User.bulkCreate([
          {
            id: 1,
            account: "766187397",
            password: "397952e52be759923246133a66a11f7f",
            nickname: "管理员",
            email: "766187397@qq.com",
            phoneNumber: "1806610689",
            avatar: "/static/images/1731140422571-7aa83266b8b64fafbfc6e39a281df3e0.jpg",
          }
        ], { ignoreDuplicates: true });
      }
    });
  } catch (error) {
    console.error('设置默认用户数据出错：', error);
  }

}

/**
 * 默认用户角色关联数据
 */
async function initUserRoleData() {
  try {
    // 验证数据库连接
    await sequelize.authenticate();
    await UserRole.sync().then(async () => {
      const existingAssociation = await UserRole.findOne({
        where: { userId: 1, roleId: 1 }
      });

      if (!existingAssociation) {
        const user = await User.findByPk(1);
        const role = await Role.findOne({ where: { name: 'admin' } });

        if (user && role) {
          await UserRole.bulkCreate([
            { userId: 1, roleId: role.id },
            // { userId: 2, roleId: 2 } // 可以添加更多默认数据
          ], { ignoreDuplicates: true });
        }
      }
    });
  } catch (error) {
    console.error('设置默认用户角色关联数据出错：', error);
  }

}

/**
 * 默认路由数据
 */
async function initRouteData() {
  try {
    // 验证数据库连接
    await sequelize.authenticate();
    // 检查是否存在 /home 路由
    let homeRoute = await Route.findOne({ where: { path: '/home' } });
    if (!homeRoute) {
      homeRoute = await Route.create({
        menuName: 'Home',
        parentId: null,
        path: '/home',
        permissionName: 'home',
        sortOrder: 1,
        icon: 'home-icon',
        meta: {}
      });
    }

    // 检查是否存在 /test 路由
    let testRoute = await Route.findOne({ where: { path: '/test' } });
    if (!testRoute) {
      testRoute = await Route.create({
        menuName: 'Test',
        parentId: null,
        path: '/test',
        permissionName: 'test',
        sortOrder: 2,
        icon: 'test-icon',
        meta: {}
      });
    }

    // 检查是否存在 /html 路由，并将其父级设置为 /home
    let htmlRoute = await Route.findOne({ where: { path: '/html' } });
    if (!htmlRoute) {
      htmlRoute = await Route.create({
        menuName: 'HTML',
        parentId: homeRoute.id,
        path: '/html',
        permissionName: 'html',
        sortOrder: 3,
        icon: 'html-icon',
        meta: {}
      });
    }
  } catch (error) {
    console.error('设置默认路由数据出错：', error);
  }
}

/**
 * 默认角色路由关联数据
 */
async function initRoleRouteData() {
  try {
    // 验证数据库连接
    await sequelize.authenticate();

    // 检查是否存在默认角色
    let adminRole = await Role.findOne({ where: { id: 1 } });
    if (!adminRole) {
      throw new Error('没有ID为1的角色！')
    }

    // 获取所有路由
    const allRoutes = await Route.findAll();
    if (!allRoutes || allRoutes.length <= 0) {
      throw new Error('路由信息为空！')
    }

    // 将角色 ID 为 1 的角色关联到所有路由
    await adminRole.setRoutes(allRoutes);
  } catch (error) {
    console.error('设置默认角色路由关联数据出错：', error);
  }
}

async function init() {
  await syncDB()
  await defaultData()
}

init()